﻿// 0808train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <limits>

using namespace std;


/*
 演出都是同时进行，一个人只能同时观看一场演出，且不能迟到早退，由于演出分布在不同的演出场地，
 所以连续观看的演出最少有 15 分钟的时间间隔，小明是一个狂热的文艺迷，想观看尽可能多的演出。

输入
第一行为一个数 N，表示演出场数，1 <= N <= 1000。
接下来 N 行，每行两个空格分割的整数，
第一个整数 T 表示演出的开始时间，第二个整数 L 表示演出的持续时间，
T 和 L 的单位为分钟，0 <= T <= 1440, 0 < L <= 100。

输入
2
720 120
840 120
输出
1
说明
第一场演出开始时间是第720分钟，经过120分钟演出结束，即第840分钟结束，
此时还需要15分钟的间隔时间，即要等到第855分钟才可以看下一场演出，
故来不及看第二场在第840分钟开始的演出。最多只能看1场演出。

输入
4
10 20
100 20
150 60
80 40

输出
3

 */

void solve01(vector<pair<int,int>>&pair_vec)
{
	sort(pair_vec.begin(), pair_vec.end(), [](pair<int,int>&a, pair<int,int>&b)
		{
			if (a.first==b.first)
			{
				return a.second < b.second;
			}
			return a.first < b.first;
		});
	int vec_size = pair_vec.size();
	vector<int>dynamic_grid(vec_size, 1);

	int max_length = 1;
	for (int curr=1; curr<vec_size; curr++)
	{
		for (int prev=0; prev<curr; prev++)
		{
			int end_time = pair_vec[prev].first+ pair_vec[prev].second;
			int start_time = pair_vec[curr].first;
			if (start_time>=end_time)
			{
				dynamic_grid[curr] = dynamic_grid[prev] + 1;
			}
			max_length = max(max_length, dynamic_grid[curr]);
		}

	}
	cout << max_length;

	//solve01------
}


void solve11(vector<pair<int, int>>& pair_vec)
{
	sort(pair_vec.begin(), pair_vec.end(), [](pair<int, int>&a, pair<int, int>&b)
		{
			if (a.first==b.first)
			{
				return a.second < b.second;
			}
			return a.first < b.first;
		});

	int vec_size = pair_vec.size();

	int result = 0;
	int prev_end = -INT_MAX;
	//[start2,end2]
	for (int curr=0;curr<vec_size;curr++)
	{
		pair<int, int>curr_pair = pair_vec[curr];
		int curr_start = curr_pair.first;
		int curr_end = curr_pair.first + curr_pair.second;
		if (prev_end<= curr_start)
		{
			result += 1;
			prev_end = curr_end;
		}
		else if (prev_end> curr_start &&prev_end<= curr_end)
		{
			continue;
		}
		else if (prev_end>curr_end)
		{
			prev_end = curr_end;
		}
	}
	cout << result;
	//solve11------
}


/*
 给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。
 返回 需要移除区间的最小数量，使剩余区间互不重叠 。

注意 只在一点上接触的区间是 不重叠的。例如 [1, 2] 和 [2, 3] 是不重叠的。


示例 1:
输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。
示例 2:
输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
示例 3:
输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。
 */

int solve02(vector<vector<int>>& intervals)
{
	sort(intervals.begin(), intervals.end(), [](vector<int>& a, vector<int>& b)
		{
			if (a[0]==b[0])
			{
				return a[1] < b[1];
			}
			return a[0] < b[0];
		});
	int vec_size = intervals.size();
	vector<int>dynamic_vec(vec_size, 1);

	int max_length=1;
	for (int curr=1;curr<vec_size; curr++)
	{
		for (int prev=0; prev<curr; prev++)
		{
			vector<int> prev_node = intervals[prev];
			vector<int> curr_node = intervals[curr];
			if (prev_node[1]<=curr_node[0])
			{
				dynamic_vec[curr] = max(dynamic_vec[curr], dynamic_vec[prev] + 1);
			}
			max_length = max(max_length, dynamic_vec[curr]);
		}
	}

	//for (auto&num:dynamic_vec)
	//{
	//	cout << num << ' ';
	//}

	return vec_size - max_length;
	//solve02-----
}

int solve21(vector<vector<int>>& intervals)
{
	//1记录上一个区间结束点prev_end
	//2prev_end<=curr_start result+=1 两个区间都取
	//3prev_end>curr_start&&prev_end<=curr_end 两个区间重叠，第二个区间不取
	//4prev_end>curr_end，前一个覆盖当前，更新prev_end

	sort(intervals.begin(), intervals.end(), [](vector<int>& a, vector<int>& b)
		{
			if (a[0]==b[0])
			{
				return a[1] < b[1];
			}
			return a[0] < b[0];
		});

	int vec_size = intervals.size();
	int result = 0;
	int prev_end = -INT_MAX;

	for (int curr=0; curr< vec_size; curr++)
	{
		int curr_start = intervals[curr][0];
		int curr_end = intervals[curr][1];

		if (prev_end<=curr_start)
		{
			result += 1;
			prev_end = curr_end;
		}
		else if (prev_end>curr_start&&prev_end<=curr_end)
		{
			continue;
		}
		else if (prev_end>=curr_end)
		{
			prev_end = curr_end;
		}

	}
	return vec_size - result;

	//solve21
}

/*
 书籍的长、宽都是整数对应(l,w)。如果书A的长宽度都比B长宽大时，则允许将B排列放在A上面。
现在有一组书籍，书籍叠放时要求书籍不能做旋转，请计算最多能有多少个书籍能叠放在一起

输入描述
输入：books = 20,16,15,11,10,10,9,10
说明：总共4本书籍，
第一本长度为20，宽度为16；
第二本书长度为15宽度为11；
依次类推，最后一本书长度为9，宽度为10

输出描述
输出：3
最多能有多少个规格书籍能叠放在一起

 */

void solve03(vector<vector<int>>&origin_grid)
{
	sort(origin_grid.begin(), origin_grid.end(), [](vector<int>& a, vector<int>& b)
		{
		if (a[0]==b[0])
		{
			return a[1] < b[1];
		}
		return a[0] < b[0];
		});
	int vec_size = origin_grid.size();
	vector<int>dynamic_vec(vec_size,1);

	int max_length = 1;
	for (int curr=1; curr<vec_size; curr++)
	{
		vector<int>curr_node = origin_grid[curr];
		for (int prev=0;prev<curr;prev++)
		{
			vector<int>prev_node = origin_grid[prev];
			if ((curr_node[0] > prev_node[0]) && (curr_node[1] > prev_node[1]))
			{
				dynamic_vec[curr] = max(dynamic_vec[curr], dynamic_vec[prev] + 1);
			}
			max_length = max(max_length, dynamic_vec[curr]);
		}
	}

	cout << max_length;

	//solve03------
}


int main()
{
	{
		//books = 20,16,15,11,10,10,9,10
		//vector<vector<int>>grid = {{20,16},{15,11},{10,10},{9,10}};
		string input;
		getline(cin, input);
		stringstream oh_sstream(input);
		string token;
		vector<int>input_vec;
		while (getline(oh_sstream, token,','))
		{
			input_vec.push_back(stoi(token));
		}
		vector<vector<int>>grid;
		for (int i=0;i<input_vec.size();i+=2)
		{
			vector<int>mini_vec = { input_vec[i],input_vec[i + 1] };
			grid.push_back(mini_vec);
		}

		//for (auto&mini_vec:grid)
		//{
		//	cout << mini_vec[0] << ' ' << mini_vec[1] << endl;
		//}

		solve03(grid);
		return 0;
	}


	{
		//intervals = [[1,2],[2,3],[3,4],[1,3]] 1
		vector<vector<int>>intervals = { {1,2},{2,3},{3,4},{1,3} };
		cout<<solve02(intervals);
		return 0;
	}


	/*
	4
	10 20
	100 20
	150 60
	80 40 3
	 */
	//vector<pair<int, int>>pair_vec = {make_pair(720,120),make_pair(840,120)};
	//vector<pair<int, int>>pair_vec = { make_pair(10,20),make_pair(100,20),make_pair(150,60),make_pair(80,40) };

	int pair_count;
	cin >> pair_count;

	vector<pair<int,int>>pair_vec(pair_count);
	for (int i=0; i<pair_count;i++)
	{
		int pair_first, pair_second;
		cin >> pair_first >> pair_second;
		pair_vec[i] = make_pair(pair_first, pair_second + 15);
	}

	//for (auto&mini_pair:pair_vec)
	//{
	//	cout << mini_pair.first << ' ' << mini_pair.second << endl;
	//}

	solve11(pair_vec);

}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
